home *** CD-ROM | disk | FTP | other *** search
/ Action Games (2008) / akcnihry1.iso / Code RED / codered.exe / Data1.cab / vid_menu.c < prev    next >
Encoding:
C/C++ Source or Header  |  2002-08-13  |  13.4 KB  |  475 lines
  1. /*
  2. Copyright (C) 1997-2001 Id Software, Inc.
  3.  
  4. This program is free software; you can redistribute it and/or
  5. modify it under the terms of the GNU General Public License
  6. as published by the Free Software Foundation; either version 2
  7. of the License, or (at your option) any later version.
  8.  
  9. This program is distributed in the hope that it will be useful,
  10. but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
  12.  
  13. See the GNU General Public License for more details.
  14.  
  15. You should have received a copy of the GNU General Public License
  16. along with this program; if not, write to the Free Software
  17. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18.  
  19. */
  20. #include "../client/client.h"
  21. #include "../client/qmenu.h"
  22.  
  23. #define REF_SOFT    0
  24. #define REF_OPENGL    1
  25. #define REF_3DFX    2
  26. #define REF_POWERVR    3
  27. #define REF_VERITE    4
  28.  
  29. extern cvar_t *vid_ref;
  30. extern cvar_t *vid_fullscreen;
  31. extern cvar_t *vid_gamma;
  32. extern cvar_t *scr_viewsize;
  33.  
  34. static cvar_t *gl_mode;
  35. static cvar_t *gl_driver;
  36. static cvar_t *gl_picmip;
  37. static cvar_t *gl_ext_palettedtexture;
  38. static cvar_t *gl_finish;
  39.  
  40. static cvar_t *sw_mode;
  41. static cvar_t *sw_stipplealpha;
  42.  
  43. extern void M_ForceMenuOff( void );
  44.  
  45. /*
  46. ====================================================================
  47.  
  48. MENU INTERACTION
  49.  
  50. ====================================================================
  51. */
  52. #define SOFTWARE_MENU 0
  53. #define OPENGL_MENU   1
  54.  
  55. static menuframework_s  s_software_menu;
  56. static menuframework_s    s_opengl_menu;
  57. static menuframework_s *s_current_menu;
  58. static int                s_current_menu_index;
  59.  
  60. static menulist_s        s_mode_list[2];
  61. static menulist_s        s_ref_list[2];
  62. static menuslider_s        s_tq_slider;
  63. static menuslider_s        s_screensize_slider[2];
  64. static menuslider_s        s_brightness_slider[2];
  65. static menulist_s          s_fs_box[2];
  66. static menulist_s          s_stipple_box;
  67. static menulist_s          s_paletted_texture_box;
  68. static menulist_s          s_finish_box;
  69. static menuaction_s        s_cancel_action[2];
  70. static menuaction_s        s_defaults_action[2];
  71.  
  72. static void DriverCallback( void *unused )
  73. {
  74.     s_ref_list[!s_current_menu_index].curvalue = s_ref_list[s_current_menu_index].curvalue;
  75.  
  76.     if ( s_ref_list[s_current_menu_index].curvalue == 0 )
  77.     {
  78.         s_current_menu = &s_software_menu;
  79.         s_current_menu_index = 0;
  80.     }
  81.     else
  82.     {
  83.         s_current_menu = &s_opengl_menu;
  84.         s_current_menu_index = 1;
  85.     }
  86.  
  87. }
  88.  
  89. static void ScreenSizeCallback( void *s )
  90. {
  91.     menuslider_s *slider = ( menuslider_s * ) s;
  92.  
  93.     Cvar_SetValue( "viewsize", slider->curvalue * 10 );
  94. }
  95.  
  96. static void BrightnessCallback( void *s )
  97. {
  98.     menuslider_s *slider = ( menuslider_s * ) s;
  99.  
  100.     if ( s_current_menu_index == SOFTWARE_MENU )
  101.         s_brightness_slider[1].curvalue = s_brightness_slider[0].curvalue;
  102.     else
  103.         s_brightness_slider[0].curvalue = s_brightness_slider[1].curvalue;
  104.  
  105.     if ( stricmp( vid_ref->string, "soft" ) == 0 )
  106.     {
  107.         float gamma = ( 0.8 - ( slider->curvalue/10.0 - 0.5 ) ) + 0.5;
  108.  
  109.         Cvar_SetValue( "vid_gamma", gamma );
  110.     }
  111. }
  112.  
  113. static void ResetDefaults( void *unused )
  114. {
  115.     VID_MenuInit();
  116. }
  117.  
  118. static void ApplyChanges( void *unused )
  119. {
  120.     float gamma;
  121.  
  122.     /*
  123.     ** make values consistent
  124.     */
  125.     s_fs_box[!s_current_menu_index].curvalue = s_fs_box[s_current_menu_index].curvalue;
  126.     s_brightness_slider[!s_current_menu_index].curvalue = s_brightness_slider[s_current_menu_index].curvalue;
  127.     s_ref_list[!s_current_menu_index].curvalue = s_ref_list[s_current_menu_index].curvalue;
  128.  
  129.     /*
  130.     ** invert sense so greater = brighter, and scale to a range of 0.5 to 1.3
  131.     */
  132.     gamma = ( 0.8 - ( s_brightness_slider[s_current_menu_index].curvalue/10.0 - 0.5 ) ) + 0.5;
  133.  
  134.     Cvar_SetValue( "vid_gamma", gamma );
  135.     Cvar_SetValue( "sw_stipplealpha", s_stipple_box.curvalue );
  136.     Cvar_SetValue( "gl_picmip", 3 - s_tq_slider.curvalue );
  137.     Cvar_SetValue( "vid_fullscreen", s_fs_box[s_current_menu_index].curvalue );
  138.     Cvar_SetValue( "gl_ext_palettedtexture", s_paletted_texture_box.curvalue );
  139.     Cvar_SetValue( "gl_finish", s_finish_box.curvalue );
  140.     Cvar_SetValue( "sw_mode", s_mode_list[SOFTWARE_MENU].curvalue );
  141.     Cvar_SetValue( "gl_mode", s_mode_list[OPENGL_MENU].curvalue );
  142.  
  143.     switch ( s_ref_list[s_current_menu_index].curvalue )
  144.     {
  145.     case REF_SOFT:
  146.         Cvar_Set( "vid_ref", "soft" );
  147.         break;
  148.     case REF_OPENGL:
  149.         Cvar_Set( "vid_ref", "gl" );
  150.         Cvar_Set( "gl_driver", "opengl32" );
  151.         break;
  152.     case REF_3DFX:
  153.         Cvar_Set( "vid_ref", "gl" );
  154.         Cvar_Set( "gl_driver", "3dfxgl" );
  155.         break;
  156.     case REF_POWERVR:
  157.         Cvar_Set( "vid_ref", "gl" );
  158.         Cvar_Set( "gl_driver", "pvrgl" );
  159.         break;
  160.     case REF_VERITE:
  161.         Cvar_Set( "vid_ref", "gl" );
  162.         Cvar_Set( "gl_driver", "veritegl" );
  163.         break;
  164.     }
  165.  
  166.     /*
  167.     ** update appropriate stuff if we're running OpenGL and gamma
  168.     ** has been modified
  169.     */
  170.     if ( stricmp( vid_ref->string, "gl" ) == 0 )
  171.     {
  172.         if ( vid_gamma->modified )
  173.         {
  174.             vid_ref->modified = true;
  175.             if ( stricmp( gl_driver->string, "3dfxgl" ) == 0 )
  176.             {
  177.                 char envbuffer[1024];
  178.                 float g;
  179.  
  180.                 vid_ref->modified = true;
  181.  
  182.                 g = 2.00 * ( 0.8 - ( vid_gamma->value - 0.5 ) ) + 1.0F;
  183.                 Com_sprintf( envbuffer, sizeof(envbuffer), "SSTV2_GAMMA=%f", g );
  184.                 putenv( envbuffer );
  185.                 Com_sprintf( envbuffer, sizeof(envbuffer), "SST_GAMMA=%f", g );
  186.                 putenv( envbuffer );
  187.  
  188.                 vid_gamma->modified = false;
  189.             }
  190.         }
  191.  
  192.         if ( gl_driver->modified )
  193.             vid_ref->modified = true;
  194.     }
  195.  
  196.     M_ForceMenuOff();
  197. }
  198.  
  199. static void CancelChanges( void *unused )
  200. {
  201.     extern void M_PopMenu( void );
  202.  
  203.     M_PopMenu();
  204. }
  205.  
  206. /*
  207. ** VID_MenuInit
  208. */
  209. void VID_MenuInit( void )
  210. {
  211.     static const char *resolutions[] = 
  212.     {
  213.         "[320 240  ]",
  214.         "[400 300  ]",
  215.         "[512 384  ]",
  216.         "[640 480  ]",
  217.         "[800 600  ]",
  218.         "[960 720  ]",
  219.         "[1024 768 ]",
  220.         "[1152 864 ]",
  221.         "[1280 960 ]",
  222.         "[1600 1200]",
  223.         "[2048 1536]",
  224.         0
  225.     };
  226.     static const char *refs[] =
  227.     {
  228.         "[software      ]",
  229.         "[default OpenGL]",
  230.         "[3Dfx OpenGL   ]",
  231.         "[PowerVR OpenGL]",
  232. //        "[Rendition OpenGL]",
  233.         0
  234.     };
  235.     static const char *yesno_names[] =
  236.     {
  237.         "no",
  238.         "yes",
  239.         0
  240.     };
  241.     int i;
  242.  
  243.     if ( !gl_driver )
  244.         gl_driver = Cvar_Get( "gl_driver", "opengl32", 0 );
  245.     if ( !gl_picmip )
  246.         gl_picmip = Cvar_Get( "gl_picmip", "0", 0 );
  247.     if ( !gl_mode )
  248.         gl_mode = Cvar_Get( "gl_mode", "3", 0 );
  249.     if ( !sw_mode )
  250.         sw_mode = Cvar_Get( "sw_mode", "0", 0 );
  251.     if ( !gl_ext_palettedtexture )
  252.         gl_ext_palettedtexture = Cvar_Get( "gl_ext_palettedtexture", "1", CVAR_ARCHIVE );
  253.     if ( !gl_finish )
  254.         gl_finish = Cvar_Get( "gl_finish", "0", CVAR_ARCHIVE );
  255.  
  256.     if ( !sw_stipplealpha )
  257.         sw_stipplealpha = Cvar_Get( "sw_stipplealpha", "0", CVAR_ARCHIVE );
  258.  
  259.     s_mode_list[SOFTWARE_MENU].curvalue = sw_mode->value;
  260.     s_mode_list[OPENGL_MENU].curvalue = gl_mode->value;
  261.  
  262.     if ( !scr_viewsize )
  263.         scr_viewsize = Cvar_Get ("viewsize", "100", CVAR_ARCHIVE);
  264.  
  265.     s_screensize_slider[SOFTWARE_MENU].curvalue = scr_viewsize->value/10;
  266.     s_screensize_slider[OPENGL_MENU].curvalue = scr_viewsize->value/10;
  267.  
  268.     if ( strcmp( vid_ref->string, "soft" ) == 0 )
  269.     {
  270.         s_current_menu_index = SOFTWARE_MENU;
  271.         s_ref_list[0].curvalue = s_ref_list[1].curvalue = REF_SOFT;
  272.     }
  273.     else if ( strcmp( vid_ref->string, "gl" ) == 0 )
  274.     {
  275.         s_current_menu_index = OPENGL_MENU;
  276.         if ( strcmp( gl_driver->string, "3dfxgl" ) == 0 )
  277.             s_ref_list[s_current_menu_index].curvalue = REF_3DFX;
  278.         else if ( strcmp( gl_driver->string, "pvrgl" ) == 0 )
  279.             s_ref_list[s_current_menu_index].curvalue = REF_POWERVR;
  280.         else if ( strcmp( gl_driver->string, "opengl32" ) == 0 )
  281.             s_ref_list[s_current_menu_index].curvalue = REF_OPENGL;
  282.         else
  283. //            s_ref_list[s_current_menu_index].curvalue = REF_VERITE;
  284.             s_ref_list[s_current_menu_index].curvalue = REF_OPENGL;
  285.     }
  286.  
  287.     s_software_menu.x = viddef.width * 0.50;
  288.     s_software_menu.nitems = 0;
  289.     s_opengl_menu.x = viddef.width * 0.50;
  290.     s_opengl_menu.nitems = 0;
  291.  
  292.     for ( i = 0; i < 2; i++ )
  293.     {
  294.         s_ref_list[i].generic.type = MTYPE_SPINCONTROL;
  295.         s_ref_list[i].generic.name = "driver";
  296.         s_ref_list[i].generic.x = 0;
  297.         s_ref_list[i].generic.y = 0;
  298.         s_ref_list[i].generic.callback = DriverCallback;
  299.         s_ref_list[i].itemnames = refs;
  300.  
  301.         s_mode_list[i].generic.type = MTYPE_SPINCONTROL;
  302.         s_mode_list[i].generic.name = "video mode";
  303.         s_mode_list[i].generic.x = 0;
  304.         s_mode_list[i].generic.y = 10;
  305.         s_mode_list[i].itemnames = resolutions;
  306.  
  307.         s_screensize_slider[i].generic.type    = MTYPE_SLIDER;
  308.         s_screensize_slider[i].generic.x        = 0;
  309.         s_screensize_slider[i].generic.y        = 20;
  310.         s_screensize_slider[i].generic.name    = "screen size";
  311.         s_screensize_slider[i].minvalue = 3;
  312.         s_screensize_slider[i].maxvalue = 12;
  313.         s_screensize_slider[i].generic.callback = ScreenSizeCallback;
  314.  
  315.         s_brightness_slider[i].generic.type    = MTYPE_SLIDER;
  316.         s_brightness_slider[i].generic.x    = 0;
  317.         s_brightness_slider[i].generic.y    = 30;
  318.         s_brightness_slider[i].generic.name    = "brightness";
  319.         s_brightness_slider[i].generic.callback = BrightnessCallback;
  320.         s_brightness_slider[i].minvalue = 5;
  321.         s_brightness_slider[i].maxvalue = 13;
  322.         s_brightness_slider[i].curvalue = ( 1.3 - vid_gamma->value + 0.5 ) * 10;
  323.  
  324.         s_fs_box[i].generic.type = MTYPE_SPINCONTROL;
  325.         s_fs_box[i].generic.x    = 0;
  326.         s_fs_box[i].generic.y    = 40;
  327.         s_fs_box[i].generic.name    = "fullscreen";
  328.         s_fs_box[i].itemnames = yesno_names;
  329.         s_fs_box[i].curvalue = vid_fullscreen->value;
  330.  
  331.         s_defaults_action[i].generic.type = MTYPE_ACTION;
  332.         s_defaults_action[i].generic.name = "reset to defaults";
  333.         s_defaults_action[i].generic.x    = 0;
  334.         s_defaults_action[i].generic.y    = 90;
  335.         s_defaults_action[i].generic.callback = ResetDefaults;
  336.  
  337.         s_cancel_action[i].generic.type = MTYPE_ACTION;
  338.         s_cancel_action[i].generic.name = "cancel";
  339.         s_cancel_action[i].generic.x    = 0;
  340.         s_cancel_action[i].generic.y    = 100;
  341.         s_cancel_action[i].generic.callback = CancelChanges;
  342.     }
  343.  
  344.     s_stipple_box.generic.type = MTYPE_SPINCONTROL;
  345.     s_stipple_box.generic.x    = 0;
  346.     s_stipple_box.generic.y    = 60;
  347.     s_stipple_box.generic.name    = "stipple alpha";
  348.     s_stipple_box.curvalue = sw_stipplealpha->value;
  349.     s_stipple_box.itemnames = yesno_names;
  350.  
  351.     s_tq_slider.generic.type    = MTYPE_SLIDER;
  352.     s_tq_slider.generic.x        = 0;
  353.     s_tq_slider.generic.y        = 60;
  354.     s_tq_slider.generic.name    = "texture quality";
  355.     s_tq_slider.minvalue = 0;
  356.     s_tq_slider.maxvalue = 3;
  357.     s_tq_slider.curvalue = 3-gl_picmip->value;
  358.  
  359.     s_paletted_texture_box.generic.type = MTYPE_SPINCONTROL;
  360.     s_paletted_texture_box.generic.x    = 0;
  361.     s_paletted_texture_box.generic.y    = 70;
  362.     s_paletted_texture_box.generic.name    = "8-bit textures";
  363.     s_paletted_texture_box.itemnames = yesno_names;
  364.     s_paletted_texture_box.curvalue = gl_ext_palettedtexture->value;
  365.  
  366.     s_finish_box.generic.type = MTYPE_SPINCONTROL;
  367.     s_finish_box.generic.x    = 0;
  368.     s_finish_box.generic.y    = 80;
  369.     s_finish_box.generic.name    = "sync every frame";
  370.     s_finish_box.curvalue = gl_finish->value;
  371.     s_finish_box.itemnames = yesno_names;
  372.  
  373.     Menu_AddItem( &s_software_menu, ( void * ) &s_ref_list[SOFTWARE_MENU] );
  374.     Menu_AddItem( &s_software_menu, ( void * ) &s_mode_list[SOFTWARE_MENU] );
  375.     Menu_AddItem( &s_software_menu, ( void * ) &s_screensize_slider[SOFTWARE_MENU] );
  376.     Menu_AddItem( &s_software_menu, ( void * ) &s_brightness_slider[SOFTWARE_MENU] );
  377.     Menu_AddItem( &s_software_menu, ( void * ) &s_fs_box[SOFTWARE_MENU] );
  378.     Menu_AddItem( &s_software_menu, ( void * ) &s_stipple_box );
  379.  
  380.     Menu_AddItem( &s_opengl_menu, ( void * ) &s_ref_list[OPENGL_MENU] );
  381.     Menu_AddItem( &s_opengl_menu, ( void * ) &s_mode_list[OPENGL_MENU] );
  382.     Menu_AddItem( &s_opengl_menu, ( void * ) &s_screensize_slider[OPENGL_MENU] );
  383.     Menu_AddItem( &s_opengl_menu, ( void * ) &s_brightness_slider[OPENGL_MENU] );
  384.     Menu_AddItem( &s_opengl_menu, ( void * ) &s_fs_box[OPENGL_MENU] );
  385.     Menu_AddItem( &s_opengl_menu, ( void * ) &s_tq_slider );
  386.     Menu_AddItem( &s_opengl_menu, ( void * ) &s_paletted_texture_box );
  387.     Menu_AddItem( &s_opengl_menu, ( void * ) &s_finish_box );
  388.  
  389.     Menu_AddItem( &s_software_menu, ( void * ) &s_defaults_action[SOFTWARE_MENU] );
  390.     Menu_AddItem( &s_software_menu, ( void * ) &s_cancel_action[SOFTWARE_MENU] );
  391.     Menu_AddItem( &s_opengl_menu, ( void * ) &s_defaults_action[OPENGL_MENU] );
  392.     Menu_AddItem( &s_opengl_menu, ( void * ) &s_cancel_action[OPENGL_MENU] );
  393.  
  394.     Menu_Center( &s_software_menu );
  395.     Menu_Center( &s_opengl_menu );
  396.     s_opengl_menu.x -= 8;
  397.     s_software_menu.x -= 8;
  398. }
  399.  
  400. /*
  401. ================
  402. VID_MenuDraw
  403. ================
  404. */
  405. void VID_MenuDraw (void)
  406. {
  407.     int w, h;
  408.  
  409.     if ( s_current_menu_index == 0 )
  410.         s_current_menu = &s_software_menu;
  411.     else
  412.         s_current_menu = &s_opengl_menu;
  413.  
  414.     /*
  415.     ** draw the banner
  416.     */
  417.     Draw_GetPicSize( &w, &h, "m_banner_video" );
  418.     Draw_Pic( viddef.width / 2 - w / 2, viddef.height /2 - 110, "m_banner_video" );
  419.  
  420.     /*
  421.     ** move cursor to a reasonable starting position
  422.     */
  423.     Menu_AdjustCursor( s_current_menu, 1 );
  424.  
  425.     /*
  426.     ** draw the menu
  427.     */
  428.     Menu_Draw( s_current_menu );
  429. }
  430.  
  431. /*
  432. ================
  433. VID_MenuKey
  434. ================
  435. */
  436. const char *VID_MenuKey( int key )
  437. {
  438.     menuframework_s *m = s_current_menu;
  439.     static const char *sound = "misc/menu1.wav";
  440.  
  441.     switch ( key )
  442.     {
  443.     case K_ESCAPE:
  444.         ApplyChanges( 0 );
  445.         return NULL;
  446.     case K_KP_UPARROW:
  447.     case K_UPARROW:
  448.         m->cursor--;
  449.         Menu_AdjustCursor( m, -1 );
  450.         break;
  451.     case K_KP_DOWNARROW:
  452.     case K_DOWNARROW:
  453.         m->cursor++;
  454.         Menu_AdjustCursor( m, 1 );
  455.         break;
  456.     case K_KP_LEFTARROW:
  457.     case K_LEFTARROW:
  458.         Menu_SlideItem( m, -1 );
  459.         break;
  460.     case K_KP_RIGHTARROW:
  461.     case K_RIGHTARROW:
  462.         Menu_SlideItem( m, 1 );
  463.         break;
  464.     case K_KP_ENTER:
  465.     case K_ENTER:
  466.         if ( !Menu_SelectItem( m ) )
  467.             ApplyChanges( NULL );
  468.         break;
  469.     }
  470.  
  471.     return sound;
  472. }
  473.  
  474.  
  475.